package cn.com.pajx.pajx_visitor_v3.utils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.text.TextUtils;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import cn.com.pajx.pajx_visitor_v3.BaseApp;

/**
 * created by ruancw on 2024/2/28.
 * 文件工具类
 */
public class FileUtil {

    public static String FOLDER = "/PAJX/photo/";

    /**
     * 判断是否有SD卡
     *
     * @return boolean
     */
    public static boolean hasSDCard() {
        String status = Environment.getExternalStorageState();
        return status.equals(Environment.MEDIA_MOUNTED);
    }

    /**
     * 建立保存头像的路径及名称
     */

    public static File saveOutputMediaFile(String mImageName) {
        File rootDir;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            rootDir = BaseApp.getInstance().getExternalFilesDir(Environment.DIRECTORY_PICTURES);
        } else {
            rootDir = Environment.getExternalStorageDirectory();
        }

        assert rootDir != null;
        File folderDir = new File(rootDir.getAbsolutePath() + FOLDER);
        if (!folderDir.exists()) {
            if (!folderDir.mkdirs()) {
                return null;
            } else folderDir.mkdirs();
        }
        File mediaFile;
        // 设置图片名字
        mediaFile = new File(folderDir.getAbsolutePath() + File.separator + mImageName + ".jpg");
        return mediaFile;
    }

    /**
     * 获取文件夹下的所有图片路径
     *
     * @param fileDir 文件路径
     * @return 文件
     */
    private static File[] getImageFiles(String fileDir) {
        File rootDir;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            rootDir = BaseApp.getInstance().getExternalFilesDir(Environment.DIRECTORY_PICTURES);
        } else {
            rootDir = Environment.getExternalStorageDirectory();
        }

        assert rootDir != null;
        File mediaStorageDir = new File(rootDir.getAbsolutePath() + FOLDER + fileDir);
        File[] listFiles = new File[0];
        if (!mediaStorageDir.exists()) {
            if (!mediaStorageDir.mkdirs()) {
                return null;
            }
        } else {
            listFiles = mediaStorageDir.listFiles();
        }
        return listFiles;
    }

    /**
     * 以流的形式保存拍照的图片到指定文件夹
     *
     * @param bitmap     要保存的图片
     * @param mImageName 要保存的文件名称
     */
    public static void saveBitmap2SD(Bitmap bitmap, String mImageName) {
        FileOutputStream fos = null;
        File bitmapFile = saveOutputMediaFile(mImageName);
        if (bitmapFile == null) {
            return;
        }
        try {
            fos = new FileOutputStream(bitmapFile);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                assert fos != null;
                fos.flush();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void saveToSystemGallery(Context context,Bitmap bmp) {
        // 首先保存图片
        File[] files=context.getExternalFilesDirs(null);
        LogUtils.e("files="+files[0]);
//        LogUtils.e("files==="+files[1]);
        File appDir = new File(Environment.getExternalStorageDirectory(), "PAJX");
        if (!appDir.exists()) {
            appDir.mkdir();
        }
        @SuppressLint("SimpleDateFormat")
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");// HH:mm:ss
        //获取当前时间
        Date date = new Date(System.currentTimeMillis());
        String fileName = simpleDateFormat.format(date) + ".jpg";
        File file = new File(appDir, fileName);
        try {
            FileOutputStream fos = new FileOutputStream(file);
            bmp.compress(Bitmap.CompressFormat.JPEG, 100, fos);
            fos.flush();
            fos.close();
        } catch (IOException e) {
            LogUtils.e("IOException="+e.getMessage());
            e.printStackTrace();
        }

        // 其次把文件插入到系统图库
        try {
            MediaStore.Images.Media.insertImage(context.getContentResolver(),
                    file.getAbsolutePath(), fileName, null);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
        Uri uri = Uri.fromFile(file);
        intent.setData(uri);
        context.sendBroadcast(intent); // 发送广播，通知图库更新
    }

    public byte[] bitmap2Bytes(Bitmap bm) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bm.compress(Bitmap.CompressFormat.JPEG, 100, bos);
        return bos.toByteArray();
    }

    /**
     * 从sd卡获取图片资源路径
     *
     * @param fileDir 文件夹名称
     * @return 路径列表
     */
    public static List<String> getImagePathFromSD(String fileDir) {
        // 图片路径存储列表
        List<String> imagePathList = new ArrayList<>();
        // 得到该路径文件夹下所有的文件
        File[] files = getImageFiles(fileDir);
        // 将所有的文件存入ArrayList中,并过滤所有图片格式的文件
        assert files != null;
        for (File file : files) {
            if (checkIsImageFile(file.getPath())) {
                imagePathList.add(file.getPath());
            }
        }
        // 返回得到的图片路径列表
        return imagePathList;
    }

    /**
     * 检查扩展名，得到图片格式的文件
     *
     * @param fName 文件名
     * @return boolean
     */
    @SuppressLint("DefaultLocale")
    private static boolean checkIsImageFile(String fName) {
        boolean isImageFile;
        // 获取扩展名
        String FileEnd = fName.substring(fName.lastIndexOf(".") + 1).toLowerCase();
        isImageFile = FileEnd.equals("jpg") || FileEnd.equals("png") || FileEnd.equals("gif")
                || FileEnd.equals("jpeg") || FileEnd.equals("bmp");
        return isImageFile;
    }

    /**
     * 判断文件是否存在
     *
     * @param strFile 文件名
     * @return 布尔类型
     */
    public static boolean fileIsExists(String strFile) {
        try {
            File f = new File(strFile);
            if (!f.exists()) {
                return false;
            }

        } catch (Exception e) {
            return false;
        }

        return true;
    }

    static double getSize(long size, long u) {
        return (double) size / (double) u;
    }


    /**
     * 获取一个文件夹大小
     *
     * @param f 文件
     * @return 大小
     */
    public static long getFileSize(File f) {
        long size = 0;
        File[] listFiles = f.listFiles();
        assert listFiles != null;
        for (File file : listFiles) {
            if (file.isDirectory()) {
                size = size + getFileSize(file);
            } else {
                size = size + file.length();
            }
        }
        return size;
    }

    /**
     * 获取根路径
     *
     * @return 路径
     */
    public static String getRootFilePath(String fileName) {
        if (hasSDCard()) {
            File rootDir;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                rootDir = BaseApp.getInstance().getExternalFilesDir(Environment.DIRECTORY_PICTURES);
            } else {
                rootDir = Environment.getExternalStorageDirectory();
            }

            assert rootDir != null;
            File file = new File(rootDir.getAbsolutePath() + FOLDER);
            if (!file.exists()) {
                file.mkdirs();
            }
            return file.getAbsolutePath();
        } else {
            return Environment.getDataDirectory().getAbsolutePath() + "/data/"; // filePath:
        }
    }

    /**
     * 删除文件，可以是文件或文件夹
     *
     * @param delFile 要删除的文件夹或文件名
     */
    public static void delete(String delFile) {
        File file = new File(delFile);
        if (!file.exists()) {
            ToastUtil.toast("删除文件失败:文件不存在！");
        } else {
            deleteSingleFile(delFile);
        }
    }

    /**
     * 删除单个文件
     *
     * @param filePath$Name 要删除的文件的文件名
     */
    private static void deleteSingleFile(String filePath$Name) {
        File file = new File(filePath$Name);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
                LogUtils.e("成功！");
            } else {
                ToastUtil.toast("失败！");
            }
        } else {
            ToastUtil.toast("文件不存在！");
        }
    }

    /**
     * 获取文件名及后缀
     */
    public static String getFileNameWithSuffix(String path) {
        if(TextUtils.isEmpty(path)){
            return "";
        }
        int start = path.lastIndexOf("/");
        if (start != -1 ) {
            return path.substring(start + 1);
        } else {
            return "";
        }
    }

    public static String getDocSuffix(String doc_name) {
        int start = doc_name.lastIndexOf(".");
        if (start != -1) {
            return doc_name.substring(start + 1);
        } else {
            return "";
        }
    }

    /**
     * 读取txt文件的内容
     *
     * @param filePath 想要读取的文件对象
     * @return 返回文件内容
     */
    @SuppressLint("NewApi")
    public static String txt2String(String filePath) {
        if (filePath == null){
            return "";
        }
        File file = new File(filePath);
        if (!file.exists()) {
            return "";
        }

        StringBuilder result = new StringBuilder();
        try {
            // 构造一个BufferedReader类来读取文件
            BufferedReader br = new BufferedReader(new FileReader(file));
            String s = null;
            // 使用readLine方法，一次读一行
            while ((s = br.readLine()) != null) {
                result.append(System.lineSeparator()).append(s);
            }
            br.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result.toString();
    }

    /**
     * 写入TXT文件
     */
    public static boolean writeTxtFile(String content, String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            return false;
        }

        RandomAccessFile mm = null;
        boolean flag = false;
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write(content.getBytes(StandardCharsets.UTF_8));
            fileOutputStream.close();
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

}
